package com.zfast.config.junit.util;

import org.apache.commons.math3.analysis.UnivariateFunction;
import org.apache.commons.math3.analysis.solvers.BrentSolver;
import org.apache.commons.math3.analysis.solvers.UnivariateSolver;
import org.apache.commons.math3.exception.NoBracketingException;
import org.junit.jupiter.api.Test;

/**
 * @author zgn
 * @Description: simJunit
 * @date 2022/1/13 0013
 */
public class 复杂数学公式Junit {
    @Test
    public void egMax() {//e.g.
        //region 1.模拟数据
        System.out.println("--------------------Start--------------------");
        //endregion

        //region 2.数据处理
        System.out.println("--------------------Deal--------------------");
        //endregion

        //region 3.数据展示
        System.out.println("--------------------Done--------------------");
        //endregion
    }

    @Test
    public void egMin() {//e.g.
        System.out.println();
    }

    @Test
    public void math3_引入_egMin() {//e.g.
        UnivariateFunction function = x -> Math.pow(x, 2) - x - 12;

        UnivariateSolver solver = new BrentSolver(-0.5);
        //int maxEval(二分法最大尝试次数,100够用呢了), FUNC f(函数), double min(区间起始值), double max(区间终点)
        double root = solver.solve(100, function, 0, 10); // 选择合适的起始区间
        //这方法用不起来
        //double root1 = solver.solve(100, function, 5); // 选择合适的起始区间

        System.out.println("Root: " + root);
    }

    public void 二分法计算_egMin() {//e.g.
        double[] doubles = {7, 423, 159, 171, 732, 156, 9, 787, 324, 925, 967, 593, 000, 000};

        for (int i = 0; i < doubles.length; i++) {
            double aDouble = doubles[i];

        }
        System.out.println();
    }

    @Test
    public void math3_羽毛球4次方程求解_egMin() {//e.g.
        // 定义四次方程
        double a = 50408995;
        double b = 1635702138161d;
        double c = 34052043036250000d;
        double d = -47945693367065000d;
        double e = 21315173750000000d;//21315173750000000d;

        UnivariateFunction function = x -> a * Math.pow(x, 4) + b * Math.pow(x, 3) + c * Math.pow(x, 2) + d * x + e;

        // 使用Brent方法求解方程根
        UnivariateSolver solver = new BrentSolver();
        double root = 0; // 选择合适的起始区间
        try {
            root = solver.solve(100, function, 1, 530);
        } catch (NoBracketingException exception) {
            System.out.println("无解");
        }

        System.out.println("Root: " + root);

        // 注意：Brent方法只能找到一个根，对于四次方程可能有多个根
        // 如果需要找到所有根，可能需要使用其他方法，如区间二分法结合多项式求值等
    }

    @Test
    public void math3_羽毛球4次方程求解_2_egMin() {
        //球初始位置
        double a = 305;
        double b = 936;
        double c = 1200;

        //球速度
        double d = 0;
        double e = 2;//21315173750000000d;
        double f = 1;

        //球加速度
        double r = 0;
        double s = 0;
        double m = 0;

        //人的位置
        double g = 305;
        double y = 1005;//21315173750000000d;
        double z = 2500;

        //人的速度
        double v = 3;

        UnivariateFunction function = x ->(
                Math.pow((a + d * x + Math.pow(r, 2) / 2 - g), 2) +
                Math.pow((b + e * x + Math.pow(s, 2) / 2 - y), 2) +
                Math.pow((c + f * x + Math.pow(m, 2) / 2 - z), 2) -
                Math.pow(v * x, 2));

        // 使用Brent方法求解方程根
        UnivariateSolver solver = new BrentSolver();
        double root = 0; // 选择合适的起始区间
        try {
            root = solver.solve(100, function, 1, 1e9);
        } catch (NoBracketingException exception) {
            System.out.println("无解");
        }

        System.out.println("Root: " + root);

        // 注意：Brent方法只能找到一个根，对于四次方程可能有多个根
        // 如果需要找到所有根，可能需要使用其他方法，如区间二分法结合多项式求值等
    }

    @Test
    public void math3_竖直上抛运动公式次方程求解_egMin() {
        //球初始位置
        double h = 1200;
        double v = 1;
        double g = -0.98;

        UnivariateFunction function = (t ->
                h+v*t+g*Math.pow(t, 2)/2);

        // 使用Brent方法求解方程根
        UnivariateSolver solver = new BrentSolver();
        double root = 0; // 选择合适的起始区间
        try {
            root = solver.solve(100, function, 0, 1e7);
        } catch (NoBracketingException exception) {
            System.out.println("无解");
        }

        System.out.println("Root: " + root);

        // 注意：Brent方法只能找到一个根，对于四次方程可能有多个根
        // 如果需要找到所有根，可能需要使用其他方法，如区间二分法结合多项式求值等
    }
}
